var express = require('express')
var router = express.Router()
//导入 薪水的模型
const SalaryModel = require('../../models/SalaryModel')
const md5 = require('md5')
//导入中间件
let checkTokenMiddleware = require('../../middlewares/checkTokenMiddleware')

//添加薪水
router.post('/Salary/AddSalary', async (req, res) => {
    //做表单验证
    //获取请求体的数据
    // console.log(req.body);
    try {
        await SalaryModel.create({ ...req.body})
        res.json({
            code: '0000', //2001 服务器问题
            msg: '添加成功',
            data: null,
            status: true,
        })
    } catch (error) {
        console.log(error)
        res.json({
            code: '2003', //2001 服务器问题
            msg: '添加失败',
            data: null,
            status: false,
        })
    }

})

// 查询所有账号（带分页和筛选条件）
router.get('/Salary/GetList', checkTokenMiddleware, async (req, res) => {
    try {
        const page = parseInt(req.query.Page) || 1; // 当前页码，默认为第一页
        const Limit = parseInt(req.query.Limit) || 10; // 每页显示的记录数，默认为 10
        let skip = null
        // 根据特定条件来动态设置 Limit
        if (Limit == 1 && page == 1) {
            skip = (page - 1) * Limit; // 计算跳过的记录数
        }
        else if (Limit == 1) {
            skip = (page - 1); // 计算跳过的记录数
        }
        else {
            skip = (page - 1) * Limit; // 计算跳过的记录数
        }



        // console.log('skip', skip);
        // 构建筛选条件对象
        const filter = {};
        if (req.query.Name) {
            console.log(req.query.Name);
            filter.name = req.query.Name;
        }
        
        console.log('filter',filter);
        
        const all = await SalaryModel.find() // 查询满足筛选条件的薪水，排除密码字段
        console.log('all',all);
        
        // 查询满足筛选条件的薪水列表
        const Salarys = await SalaryModel.find(filter) // 查询满足筛选条件的薪水，排除密码字段
            .skip(skip) // 跳过指定数量的记录
            .limit(Limit); // 限制返回的记录数，使用前端传递的 Limit 参数

        // 查询满足筛选条件的薪水总数
        const count = await SalaryModel.countDocuments(filter);
        res.json({
            count: '',
            code: '0000',
            msg: '查询成功',
            data: Salarys,
            count: count, // 返回数据总数
            status: true,
        });
    } catch (error) {
        console.log(error);
        
        res.json({
            code: '2004', // 自定义错误码
            msg: '查询失败',
            data: null,
            status: false,
        });
    }
});

// 删除薪水
router.delete('/Salary/DeleteSalary/:id', checkTokenMiddleware, async (req, res) => {
    const SalaryId = req.params.id;
    console.log(SalaryId);
    try {

        // 在数据库中查找薪水并删除
        const deletedSalary = await SalaryModel.findByIdAndDelete(SalaryId);

        if (!deletedSalary) {
            // 如果找不到要删除的薪水，返回错误信息
            res.json({
                code: '2005', // 自定义错误码
                msg: '未找到要删除的薪水',
                data: null,
                status: false,
            });
            return;
        }

        // 薪水删除成功，返回成功信息
        res.json({
            code: '0000',
            msg: '薪水删除成功',
            data: null,
            status: true,
        });
    } catch (error) {
        // 删除操作出现错误，返回错误信息
        res.json({
            code: '2006', // 自定义错误码
            msg: '薪水删除失败',
            data: null,
            status: false,
        });
    }
});

// 删除多个薪水
router.delete('/Salary/DeleteSalarys', checkTokenMiddleware, async (req, res) => {
    const ids = req.body.ids; // 获取要删除的薪水 ID 数组
    console.log(ids);
    try {
        // 在数据库中查找并删除多个薪水
        const deletedSalarys = await SalaryModel.deleteMany({ _id: { $in: ids } });

        if (deletedSalarys.deletedCount === 0) {
            // 如果没有找到要删除的薪水，返回错误信息
            res.json({
                code: '2005', // 自定义错误码
                msg: '未找到要删除的薪水',
                data: null,
                status: false,
            });  
        } 
        else {
            // 薪水删除成功，返回成功信息
            res.json({
                code: '0000',
                msg: '薪水删除成功',
                data: null,
                status: true,
            }); 
        }
    }  catch (error) {
        // 删除操作出现错误，返回错误信息
        res.json({
            code: '2006', // 自定义错误码
            msg: '薪水删除失败',
            data: null,
            status: false,
        });
    }
})

// 修改薪水信息 (POST 请求)
router.post('/Salary/EditSalary', checkTokenMiddleware, async (req, res) => {
    try {
        const SalaryId = req.body._id;
        const updatedSalaryData = req.body; // 从请求体中获取更新后的薪水数据
        // 在数据库中查找薪水并更新信息
        const updatedSalary = await SalaryModel.findByIdAndUpdate(
            SalaryId,
            updatedSalaryData,
            { new: true }
        );

        if (!updatedSalary) {
            // 如果找不到要更新的薪水，返回错误信息
            res.json({
                code: '2007', // 自定义错误码
                msg: '未找到要更新的薪水',
                data: null,
                status: false,
            });
            return;
        }

        // 薪水信息更新成功，返回成功信息和更新后的薪水数据
        res.json({
            code: '0000',
            msg: '薪水信息更新成功',
            data: updatedSalary,
            status: true,
        });
    } catch (error) {
        // 更新操作出现错误，返回错误信息
        res.json({
            code: '2008', // 自定义错误码
            msg: '薪水信息更新失败',
            data: null,
            status: false,
        });
    }
});

module.exports = router
